// use std::{io, sync::Arc};
//
// use c_cim::message::{ChatType, Opration};
// use tokio::{
//     io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
//     net::TcpStream,
//     sync::mpsc,
// };
//
// const LOCAL_SERVER: &str = "127.0.0.1:8888";
//
// #[tokio::main]
//
// async fn main() -> Result<(), Box<dyn std::error::Error>> {
//     let mut client = TcpStream::connect(LOCAL_SERVER).await?;
//
//     // 从io::stdin
//
//     let (tx, mut rx) = mpsc::channel::<String>(1024);
//
//     tokio::spawn(async move {
//         let (r, mut w) = client.split();
//
//         let mut r = BufReader::new(r);
//
//         let mut line = String::new();
//
//         loop {
//             tokio::select! {
//
//                 result = r.read_line(&mut line) => {
//
//                     if result.unwrap() == 0 {
//
//                         break;
//
//                     }
//
//             let opration_rc = Arc::new(Opration::parse_from_str(&line));
//             let chat = opration_rc.as_ref().chat.clone();
//
//             if let Some(chat) = chat {
//                 let message = opration_rc.as_ref().message.clone();
//                 let map = match chat.chat_type {
//                     ChatType::Person => {
//                         format!("来自好友:{}的消息：{}\n", chat.no, message)
//                     }
//                     ChatType::Meet => {
//                         format!("来自群聊:{}的消息：{}\n", chat.no, message)
//                     }
//                 };
//                 println!("{}", map);
//             }
//
//                     line.clear();
//
//                 }
//
//                 result = rx.recv() => {
//
//                     let msg = result.unwrap();
//
//                     // println!("msg send: {}", msg);
//
//                     w.write_all(msg.as_bytes()).await.unwrap();
//
//                 }
//
//             }
//         }
//     });
//
//     println!("msg:");
//
//     loop {
//         let mut buff = String::new();
//
//         io::stdin()
//             .read_line(&mut buff)
//             .expect("reading from stdin failed");
//
//         tx.send(buff.clone()).await.unwrap();
//
//         buff.clear();
//     }
//
//     // Ok(())
// }
//
use std::net::SocketAddr;

use axum::{
    extract::ws::{WebSocket, WebSocketUpgrade},
    response::Response,
    routing::get,
    Router,
};
use c_cim::message::Message;
use tokio::{
    io::{AsyncReadExt, AsyncWriteExt},
    net::TcpStream,
    select,
    sync::mpsc::channel,
};
#[tokio::main]
async fn main() {
    c_log::Logger::new().init();
    log::info!("server log inited");
    let app = Router::new().route("/ws", get(handler));
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn handler(ws: WebSocketUpgrade) -> Response {
    ws.on_upgrade(handle_socket)
}

async fn handle_socket(mut socket: WebSocket) {
    let addr = SocketAddr::from(([127, 0, 0, 1], 8888));
    let connection = TcpStream::connect(addr).await.unwrap();
    let (mut read, mut write) = connection.into_split();
    let (tx, mut rx) = channel::<String>(1024);
    tokio::spawn(async move {
        let mut buf = [0; 1024];

        loop {
            let n = read.read(&mut buf).await.unwrap();
            if n == 0 {
                break;
            }
            let msg = String::from_utf8(buf[0..n].to_vec()).unwrap();
            log::info!("msg from server {}", msg);

            tx.send(msg).await.unwrap();

            // let opration_rc = Arc::new(Opration::parse_from_str(&msg));
            // let chat = opration_rc.as_ref().chat.clone();

            // if let Some(chat) = chat {
            // let message = opration_rc.as_ref().message.clone();
            // let map = match chat.chat_type {
            //     ChatType::Person => {
            //         format!("来自好友:{}的消息：{}\n", chat.no, message)
            //     }
            //     ChatType::Meet => {
            //         format!("来自群聊:{}的消息：{}\n", chat.no, message)
            //     }
            // };
            // println!("msg from server1:{:?}", map);
            // tx.send(map).await.unwrap();

            // println!("msg from server1{:?}", message);
            // tx.send(message).await.unwrap();
            // }
        }
    });
    loop {
        select! {
             result= rx.recv()=>{
              println!("msg from server2{:?}",result);
                 let msg =result.unwrap();
              socket.send(axum::extract::ws::Message::Text(msg)).await.unwrap();
            }
            result=socket.recv()=>{
               if let Some(Ok(msg)) =  result {
                let text = msg.to_text().unwrap();
                println!("msg from client{:?}", text);
                write.write_all(text.as_bytes()).await.unwrap();
        }
            }
        }
    }
}
